import com.sun.deploy.uitoolkit.impl.fx.AppletStageManager;

import java.util.Arrays;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: LXW
 * Date: 2022-01-12
 * Time: 11:46
 */
public class TestDemo {
    public static void myTostring(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length-1; i++) {
            System.out.print(arr[i]+",");
        }
        System.out.println(arr[arr.length-1]+"]");
    }

    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        myTostring(arr);
    }
    // foreach 循环与for循环的区别:for循环是可以拿到下标的，foreach循环拿不到下标
    public static void main21(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
        System.out.println();
        for (int x:arr) {
            System.out.print(x);
        }
    }
    //针对有序数组, 可以使用更高效的二分查找，并且随着数组元素个数越多, 二分的优势就越大
    public static void main20(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        int n = 6;
        int left = 0;
        int right = arr.length-1;

        while (left <= right) {
            int num = (left + right) / 2;
            if (arr[num] == n) {
                System.out.println(num + 1);
                break;
            }else if (arr[num] < n) {
                left = num + 1;
            }else if (arr[num] > n) {
                right = num - 1;
            }else {
                System.out.println("没找到");
            }
        }
    }
    // 查找数组中指定元素，给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.
    public static void main19(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        int n = 3;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == n) {
                System.out.println(i+1);
                break;
            }
        }
        System.out.println("没找到");
    }
    // 求数组中元素的平均值
    public static void main18(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        double average = sum/arr.length;
        System.out.println(average);
    }
    // 找数组中的最大元素
    public static void main17(String[] args) {
        int[] arr = {1,2,3,4,5};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println(max);
    }
    // 复制一个数组
    public static void main16(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] newarr = Arrays.copyOf(arr,arr.length);// 复制一个新的数组，第一个参数是要复制的数组名，第二个参数是新数组的范围
        System.out.println("arr"+Arrays.toString(arr));
        System.out.println("newarr"+Arrays.toString(newarr));
        int[] ret = Arrays.copyOfRange(arr,2,4);// 参数分别是需要复制的数组，后面两个是范围，注意是左闭右开
        System.out.println("ret"+Arrays.toString(ret));
    }
    // 数组转字符串
    public static void main15(String[] args) {
        int[] arr = {1,2,3,4,5};
        String newarr = Arrays.toString(arr); // 使用Arrays类中的同string方法可以将数组转化为字符串，
        System.out.println(newarr);          // 这样打印数组就更方便了，不需要使用循环遍历在打印数组
    }
    // 返回一个新的数组
    public static int[] transform(int[] arr) {
        int[] ret = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            ret[i] = 2*arr[i];
        }
        return ret;
    }
    public static void printarr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }
    public static void main14(String[] args) {
        int[] arr = {1,2,3,4,5};
        int[] ret = transform(arr);
        printarr(ret);
        System.out.println();
        printarr(arr);

    }
    // 有一组数据，只有一个数字是出现一次，其它是两次请找出这个数字
    public static void main13(String[] args) {
        int[] arr = {1,2,3,2,1};
        int num = arr[0];
        for (int i = 1; i < arr.length; i++) {
            num = num ^ arr[i];
        }
        System.out.println(num);
    }
    // 打印 X 图形
    public static void main12(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if ((i == j) || (i + j == n-1)) {
                    System.out.print("*");
                }else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
    // 调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序
    public static void main11(String[] args) {
        int[] arr = {1,2,3,4,5};
        int left = 0;
        int right = arr.length-1;
        while (left < right) {
            while (left < right && arr[left] % 2 != 0) {
                left++;
            }
            while (left < right && arr[right] % 2 == 0) {
                right--;
            }
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
        for (int i = 0; i < 5; i++) {
            System.out.print(arr[i]);
        }
    }
    // 2. 实现代码: 递归求 N 的阶乘
    public static int fact(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n*fact(n-1);
        }
    }
    public static void main3(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(fact(n));
    }
    // 实现代码: 递归求 1 + 2 + 3 + ... + 10
    public static int sum(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n + sum(n - 1);
        }
    }
    public static void main4(String[] args) {
        int n = 10;
        System.out.println(sum(n));
    }
    // 实现代码: 按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)
    public static void print(int n) {
        if (n < 10) {
            System.out.print(n);
        }else {
            print(n / 10);
            System.out.print(n % 10);

        }
    }
    public static void main5(String[] args) {
        int n = 1234;
        print(n);
    }
    // 实现代码: 写一个递归方法，输入一个非负整数，返回组成它的数字之和.
    public static int sumnum(int n) {
        if (n < 9) {
            return n;
        }else {
            return sumnum(n / 10)+n % 10;
        }
    }
    public static void main6(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(sumnum(n));
    }
    // 实现代码: 求斐波那契数列的第 N 项
    public static int fibo(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }else {
            return fibo(n - 1) + fibo(n - 2);
        }
    }
    public static void main7(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(fibo(n));
    }
    // 实现代码: 求解汉诺塔问题(提示, 使用递归)
    public static void move(char pos1,char pos2) {
        System.out.print(pos1+"->"+pos2+" ");
    }

    /**
     *
     * @param n 盘子的个数
     * @param pos1 盘子的起始位置
     * @param pos2 盘子的中转位置
     * @param pos3 盘子的最终位置
     */
    public static void hanio(int n,char pos1,char pos2,char pos3) {
        if (n == 1) {
            move(pos1,pos3);
        }else {
            hanio(n-1,pos1, pos3,pos2);
            move(pos1,pos3);
            hanio(n-1,pos2,pos1,pos3);

        }
    }
    public static void main22(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        hanio(n,'A','B', 'C');
    }
    // 实现代码: 青蛙跳台阶问题(提示, 使用递归)一只青蛙一次可以跳上 1 级台阶，也可以跳上2 级。求该青蛙跳上一个n 级的台阶总共有多少种跳法
    public static int frogJump(int n) {
        if (n == 1 || n == 2) {
            return n;
        }else {
            return frogJump(n - 1) + frogJump(n - 2);
        }
    }
    public static void main8(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(frogJump(n));
    }
    //  用递归计算1！+2！+3！+4！+5!
    public static int addNum(int n) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            sum += fac(i);
        }
        return sum;
    }
    public static void main9(String[] args) {
        int n = 5;
        System.out.println(addNum(n));
    }
    // 递归计算5的阶乘
    public static int fac(int n) {
        if (n == 1) {
            return 1;
        }else {
            return n * fac(n - 1);
        }
    }
    public static void main10(String[] args) {
        int n = 5;
        System.out.println(fac(n));
    }
    // 计算1! + 2! + 3! + 4! + 5!
    public static void main2(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) {
            int ret = 1;
            for (int j = 1; j <= i; j++) {
                ret *= j;
            }
            sum += ret;
        }
        System.out.println(sum);
    }
    // 计算5的阶乘
    public static void main1(String[] args) {
        int ret = 1;
        for (int i = 1; i <= 5; i++) {
            ret *= i;
        }
    }
}
